home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / stut_src / datadirs.c < prev    next >
C/C++ Source or Header  |  1996-05-27  |  26KB  |  1,150 lines
  1. /*
  2.  * datadirs.c
  3.  *
  4.  * Purpose:
  5.  * --------
  6.  *    Gestion des "dossiers" virtuels du ramdisque virtuel!
  7.  *
  8.  * History:
  9.  * --------
  10.  * fplanque: Created
  11.  * 09.05.94: fplanque: les fichiers .h pour ressources avaient disparu
  12.  *                    lors de l'ajout de commentaires - remis en place.
  13.  */
  14.  
  15.  
  16.      #include "!OPTIONS.H"                /* Options de compilation */         
  17.     #define    THIS_FILE    "DATADIRS.C v1.00 - 03.95"
  18.           
  19.  
  20. /*
  21.  * System headers:
  22.  */
  23.     #include    <stdio.h>                /* header standard */
  24.     #include <string.h>                /* strcopy */
  25.     #include    <ext.h>                    /* MAXPATH... */
  26.     #include <assert.h>
  27.     
  28.     
  29. /*
  30.  * Custom headers:
  31.  */
  32.     #include "SPEC_PU.H"
  33.     #include "S_MALLOC.H"
  34.     #include "AESDEF.H" 
  35.     #include    "DEBUG_PU.H"    
  36.     #include "DATPG_PU.H"
  37.     #include "DTDIR_PU.H"
  38.     #include "DATAGRPS.H"
  39.     #include "OBJCT_PU.H"
  40.  
  41.    
  42. /*
  43.  * ------------------------ VARIABLES -------------------------
  44.  */
  45.  
  46. /*
  47.  * External variables: 
  48.  */
  49.     /* 
  50.      * Ic“nes: 
  51.      */
  52.     extern    OBJECT        *G_desktop_adr;        /* Ptr sur arbre bureau */
  53.     extern    WIPARAMS        *G_desk_params_adr;    /* ParamŠtres de la "fenˆtre bureau" */
  54.     /* 
  55.      * Fenˆtres
  56.      */
  57.     extern    WIPARAMS        *G_wi_list_adr;    /* Adresse de l'arbre de paramŠtres */
  58.     /* 
  59.      * Fichiers: 
  60.      */
  61.     extern    char    G_filename[ 13 ];            /* Nom du fichier … charger ex:TEST.TXT */
  62.     extern    char    G_filepath[ MAXPATH ];    /* Chemin du fichier … charger ex:D\EXEMPLE */
  63.     /* 
  64.      * Desktop: 
  65.      */
  66.     extern    DATAGROUP    *    G_datagroups;        /* Pointeur sur tableau de G_datagroups */
  67.     extern    WIPARAMS        *    G_selection_adr;    /* S‚lection courante */
  68.  
  69. /*
  70.  * Public variables: 
  71.  */
  72.     
  73. /*
  74.  * Private variables: 
  75.  */
  76.  
  77. /*
  78.  * ------------------------ FUNCTIONS -------------------------
  79.  */
  80.  
  81. /*
  82.  * create_emptyDataDir(-)
  83.  *
  84.  * Purpose:
  85.  * --------
  86.  * Cr‚e un DATADIR vide
  87.  *
  88.  * History:
  89.  * --------
  90.  * 1993: fplanque: Created
  91.  * 15.07.94: Init des ptrs sur DATAGOUP et DATADIR parent
  92.  */
  93. DATADIR    *    create_EmptyDataDir(                        /* Out: Ptr sur directory cr‚‚ */
  94.                     DATAGROUP    *    pDataGroup,            /* In:  Groupe dans lequel on cr‚e ce dossier */
  95.                     DATADIR        *    pDataDir_parent )    /* In:  Directory parent de celui-ci */
  96. {
  97.     /* 
  98.      * Cr‚e un emplacement m‚moire pour ce dossier: 
  99.      */
  100.     DATADIR    *    new_dir = (DATADIR *) MALLOC( sizeof( DATADIR ) );
  101.     DATASTATE    DataState;
  102.  
  103.     /*
  104.      * V‚rifie coh‚rence des paramŠtres:
  105.      */
  106.     if( pDataDir_parent != NULL && pDataDir_parent -> pDataGroup != pDataGroup )
  107.     {
  108.         signale( "Incoh‚rence DATAGROUP lors de la cr‚ation d'un DATADIR" );
  109.     }
  110.     
  111.     /*
  112.      * Initialise pointeurs et variables du dossier: 
  113.      */
  114.     new_dir -> pDataGroup    = pDataGroup;    
  115.     new_dir -> pDataDir_parent = pDataDir_parent;
  116.  
  117.     new_dir -> iconblks        = NULL;        /* Pas d'ic“nes! */
  118.  
  119.     new_dir -> nb_elts        = 0;            /* Vide */
  120.     new_dir -> data_start    = NULL;        /* Vide */
  121.     new_dir -> data_end        = NULL;        /* Vide */
  122.  
  123.     /*
  124.      * Pas d'infos compl‚mentaires:
  125.      * Ces infos compl‚mentaires ne sont utilis‚es que par les dossiers ARBO
  126.      */
  127.     new_dir -> dir_spec        = NULL;        
  128.  
  129.     DataState .b_open            = FALSE0;    /* INUTILISE! */
  130.     DataState .sstate            = SSTATE_EMPTY;    /* tat: VIDE */
  131.     new_dir -> DataState        = DataState;            
  132.     new_dir -> nb_dirs        = 0;            /* Aucune fen DIR ouverte sur ces donn‚es */
  133.     new_dir -> nb_edits        = 0;            /* Aucune fen d'‚dition ouverte sur ces donn‚es */
  134.  
  135.     /*
  136.      * Renvoie adresse du dossier vide: 
  137.      */
  138.     return    new_dir;
  139. }
  140.  
  141.  
  142. /*
  143.  * DataDir_Destruct(-)
  144.  *
  145.  * Destruction d'un dtagroup VIDE
  146.  *
  147.  * 16.12.94: fplanque: Created
  148.  * 14.02.95: verified mallocs
  149.  */
  150. void    DataDir_Destruct(
  151.             DATADIR    *    pDataDir )    /* In: Datadir … d‚truire */
  152. {
  153.     assert( pDataDir -> iconblks == NULL );
  154.     assert( pDataDir -> dir_spec == NULL );
  155.     assert( pDataDir -> nb_elts == 0 );
  156.     
  157.     /*
  158.      * Efface le datagroup:
  159.      */
  160.     FREE( pDataDir );
  161. }
  162.  
  163.  
  164. /*
  165.  * dataDir_getSavState(-)
  166.  *
  167.  * Purpose:
  168.  * --------
  169.  * Indique si le DATADIR a ‚t‚ sauv‚e ou non
  170.  *
  171.  * History:
  172.  * --------
  173.  * 06.08.94: fplanque: Created
  174.  * 08.08.94: gŠre les ptrs NULLs comme des dirs vierges
  175.  */
  176. SSTATE dataDir_getSavState(            /* Out: Satut sauvegarde */
  177.                 DATADIR    *    pDataDir )    /* In:  Datadir concern‚ */
  178. {
  179.     if( pDataDir == NULL )
  180.     {    /*
  181.          * Dans le cas d'un dossier arbo vierge:
  182.          */
  183.         return    SSTATE_EMPTY;
  184.     }
  185.     else
  186.     {
  187.         return    pDataDir -> DataState .sstate;
  188.     }
  189. }
  190.  
  191.  
  192.  
  193. /*
  194.  * dataDir_setSavState(-)
  195.  *
  196.  * Purpose:
  197.  * --------
  198.  * M‚morise le fait que le DATADIR ait ‚t‚ sauv‚e ou non
  199.  *
  200.  * Suggest:
  201.  * --------
  202.  * Implement recursivity:
  203.  *
  204.  * History:
  205.  * --------
  206.  * 07.08.94: fplanque: Created
  207.  * 02.10.94: en cas de SAVED: applique aux enfants du dir courant
  208.  */
  209. void dataDir_setSavState(
  210.             DATADIR *    pDataDir,        /* In: DATADIR concern‚ */
  211.             SSTATE         sstate,            /* In: Etat */
  212.             BOOL            b_GrafUpdate )    /* In: S'il faut faut r‚afficher les ic“ne correspondantes... */
  213. {
  214.     if( pDataDir -> DataState .sstate == sstate )
  215.     {    /*
  216.          * S'Il n'y a rien … changer!
  217.          */
  218.         return;            /* On ne fera bien sur pas d'Update graphique.. (Time is Money :) */
  219.     }
  220.     
  221.     /*
  222.      * Modifie ‚tat de la page:
  223.      */
  224.     pDataDir -> DataState .sstate = sstate;
  225.  
  226.     /*
  227.      * Update graphique:
  228.      */
  229.     if( b_GrafUpdate )
  230.     {
  231.         if( pDataDir -> pDataDir_parent != NULL )
  232.         {
  233.             signale( "Recursive DATADIRs not yet supported" );
  234.         }
  235.         else
  236.         {    /*
  237.              * Update de l'icone du DATAGROUP:
  238.              */
  239.             int        n_icone = pDataDir -> pDataGroup -> icon_no;
  240.  
  241.             /*
  242.              * Modifie le caractŠre de l'ic“ne:
  243.              */    
  244.             update_iconChar( &(G_desktop_adr[ n_icone ]), sstate );
  245.  
  246.             /*
  247.              * R‚affiche l'ic“ne:
  248.              */
  249.             redraw_icon( G_desk_params_adr, n_icone, n_icone, TAKE_CTRL );
  250.         }
  251.     }
  252.  
  253.     /*
  254.      * Transmissions r‚cursives:
  255.      */    
  256.     switch( sstate )
  257.     {
  258.         case    SSTATE_MODIFIED:
  259.             /*
  260.              * A FAIRE: Transmettre recursivement au parent si SSTATE_MODIFIED...
  261.              */
  262.             break;
  263.             
  264.         case     SSTATE_SAVED:
  265.         {    /*
  266.              * On doit transmettre le statut saved … tous les descendants:
  267.              */
  268.             DATAPAGE * pDataPage;
  269.             
  270.             for(    pDataPage = pDataDir -> data_start;
  271.                     pDataPage != NULL;
  272.                     pDataPage = pDataPage -> next )
  273.             {    /*
  274.                   * Update de la page mais pas de son dir (c'est d‚j… fait ci-dessus)
  275.                   */            
  276.                 dataPage_chgSavState( pDataPage,    SSTATE_SAVED, TRUE_1, FALSE0 );
  277.             }
  278.         }    
  279.             break;    
  280.     }
  281.  
  282.  
  283. }
  284.  
  285.  
  286.  
  287. /*
  288.  * dataDir_UpdatePageIcon(-)
  289.  *
  290.  * Purpose:
  291.  * --------
  292.  * - update du char de l'ic“ne d'aprŠs SSTATE de la page
  293.  * - r‚affiche une Icone de DataPage dans tous les datagroups o— elle
  294.  *   apparait.
  295.  *
  296.  * Suggest:
  297.  * --------
  298.  * Il faut repositionner le formulaire pour chaque fenetre
  299.  * ARBO TREE … redessiner, en effet ces fenetres partagent un seul formulaire
  300.  *
  301.  * History:
  302.  * --------
  303.  * 11.08.94: fplanque: Transfered from dataPage_setSavState()
  304.  */ 
  305. void    dataDir_UpdatePageIcon(
  306.             DATADIR    *    pDataDir,        /* In: Dossier concern‚ */
  307.             DATAPAGE    *    pDataPage )        /* In: DataPage concern‚e */
  308. {
  309.     if ( pDataDir -> nb_dirs > 0 )
  310.     {    /*
  311.          * Si il y a une/des fenˆtres ouvertes sur ce dossier: 
  312.          * On va faire une update dans ces fenˆtres: 
  313.          */
  314.         OBJECT * pObj_Tree;
  315.         int        n_icone;
  316.         
  317.         /*
  318.          * Trouve 1Šre fenˆtre ou apparait le dossier:
  319.          */
  320.         WIPARAMS * pWiParams = find_datawindow2( (unsigned long) pDataDir, G_wi_list_adr );
  321.         if( pWiParams == NULL )
  322.         {
  323.             signale( "Impossible de trouver une fenˆtre correspondante" );
  324.             return;
  325.         }        
  326.  
  327.         /*
  328.          * Pointeur sur l'arbre d'objets repr‚sentant le directory:
  329.          */
  330.         pObj_Tree = (pWiParams -> draw_ptr.tree); 
  331.  
  332.         /*
  333.          * Cherche la position de l'ic“ne concern‚e:
  334.          */
  335.         n_icone = find_iconByNamePtr( pObj_Tree, pDataPage -> nom );
  336.         if( n_icone == NIL_1 )
  337.         {
  338.             signale( "Impossible de trouver l'ic“ne correspondante" );
  339.             return;
  340.         }
  341.  
  342.         /*
  343.          * Modifie le caractŠre de l'ic“ne:
  344.          */    
  345.         update_iconChar( &(pObj_Tree[ n_icone ]), dataPage_getSavState( pDataPage ) );
  346.  
  347.         /*
  348.          * R‚affiche l'ic“ne dans la fenˆtre courante:
  349.          */
  350.         redraw_icon( pWiParams, n_icone, n_icone,    TAKE_CTRL );
  351.  
  352.         /*
  353.          * On s'occupe maintenant des autres fenˆtres:
  354.          */
  355.         /* printf( "Nb dirs = %d\n" , pDataDir -> nb_dirs  ); */
  356.         if ( pDataDir -> nb_dirs > 1 )
  357.         {    /*
  358.              * S'il y a d'autres fenetres ouvertes sur le DATADIR,
  359.              * nous allons actualiser leur contenu maintenant!
  360.              * nous allons juste faire un redraw des ic“nes!
  361.              * En effet la structure des fenˆtres DATADIRS est telle
  362.              * qu'elles partages toutes les mˆmes ICONBLKS: donc le
  363.              * caractŠre est d‚j… mis … jour.
  364.              */
  365.             while( (pWiParams = find_datawindow2( (unsigned long) pDataDir, pWiParams -> next )) != NULL )
  366.             {    /*
  367.                  * Tant qu'on a trouv‚ une fenˆtre ouverte sur ce dir:
  368.                  * Pointeur sur l'arbre d'objets repr‚sentant le directory:
  369.                  */
  370.                 pObj_Tree = (pWiParams -> draw_ptr.tree); 
  371.             
  372.                 /*
  373.                  * Cherche la position de l'ic“ne concern‚e:
  374.                  */
  375.                 n_icone = find_iconByNamePtr( pObj_Tree, pDataPage -> nom );
  376.                 if( n_icone == NIL_1 )
  377.                 {
  378.                     signale( "Impossible de trouver l'ic“ne correspondante" );
  379.                     return;
  380.                 }
  381.  
  382.                 /*
  383.                  * R‚affiche l'ic“ne dans la fenˆtre courante:
  384.                  */
  385.                 redraw_icon( pWiParams, n_icone, n_icone,    TAKE_CTRL );
  386.             
  387.             }
  388.         }
  389.     }
  390. }
  391.  
  392.  
  393.  
  394. /*
  395.  * dataDir_InsertStdDataPg(-)
  396.  *
  397.  * Purpose:
  398.  * --------
  399.  * Cr‚er une nouvelle DATAPAGE
  400.  * portant le nom sp‚cifi‚
  401.  * dans le DATADIR sp‚cifi‚
  402.  * en effa‡ant la page actuelle si elle existe d‚j…!
  403.  *
  404.  * Algorythm:
  405.  * ----------  
  406.  *
  407.  * Suggest:
  408.  * ------
  409.  * Update status modif
  410.  * Demande confirmation de l'‚crasement
  411.  *
  412.  * History:
  413.  * --------
  414.  * 06.07.94: fplanque: Created based on create_newDataPage()
  415.  * 02.09.94: ne prend plus de ptr sur datagroup, slt sur datadir
  416.  */
  417. DATAPAGE    *    dataDir_InsertStdDataPg( 
  418.                     const char    *    pS_name,        /* In: Nom de la page … cr‚er */
  419.                     DATADIR        *    pDataDir )    /* In: Datadir ds lequel on veut cr‚er */
  420. {
  421.     DATAGROUP *    pDataGroup = pDataDir -> pDataGroup;    /* Datagroup ds lequel on veut cr‚er */
  422.     DATAPAGE     *    pDataPage;            /* "Page" en cours de cr‚ation */
  423.  
  424.     /*
  425.      * Type des donn‚es … stocker ds DATAGROUP/DATAPAGE:
  426.      */
  427.     DATATYPE DataType = pDataGroup -> DataType;
  428.  
  429.     /*
  430.      * V‚rifie que le nom est valide
  431.      */
  432.     if ( pS_name == NULL )
  433.     {    /*
  434.          * Nom invalide:
  435.          */
  436.         ping();
  437.         return NULL;
  438.      }
  439.     
  440.     /*
  441.      * Si on a donn‚ un nom valide: 
  442.      * Teste si la page existe d‚j…:
  443.      */
  444.     pDataPage = page_adr_bynamecmp( pDataDir, pS_name );
  445.     
  446.     if( pDataPage == NULL )
  447.     {    /*
  448.          * Page n'existe pas encore:
  449.          * Cr‚e zone d'info DATAPAGE standard VIDE:INVALIDE
  450.          * … remplir dŠs le retour de la fonction
  451.          */
  452.         pDataPage = create_std_datapage( DataType, pS_name );
  453.     
  454.         /* 
  455.          * Relie la nlle "page" aux autres: 
  456.          */
  457.         attach_new_data( pDataDir, pDataPage );
  458.  
  459.     }
  460.     else
  461.     {    /*
  462.           * Page existe d‚j…:
  463.           * On efface son contenu:
  464.           */
  465.         dataPg_resetdata( pDataPage );
  466.     
  467.     }
  468.  
  469.     return    pDataPage;
  470. }
  471.  
  472.  
  473.  
  474. /*
  475.  * attach_new_data(-)
  476.  *
  477.  * Purpose:
  478.  * --------
  479.  * Relie une nouvelle DATAPAGE aux autres d'un DATADIR
  480.  *
  481.  * Algorythm:
  482.  * ----------  
  483.  * Recherche position … partir de la fin 
  484.  * pour optimiser temps de recherche lors du chargement d'un 
  485.  * fichier o— les pages sont d‚j… dans l'ordre alphab‚tique
  486.  *
  487.  * Suggest:
  488.  * ------
  489.  * Mettre ‡a ds un fichier de m‚thodes
  490.  *
  491.  * History:
  492.  * --------
  493.  * 1993: fplanque: Created
  494.  * 15.12.94: ptr de la page vers son datadir
  495.  * 09.04.95: insertion l… o— il faut (gestion alphab‚tique)
  496.  */
  497. void    attach_new_data( 
  498.             DATADIR    *    datadir,         /* In: DATADIR dans lequel on ajoute une DATAPAGE */
  499.             DATAPAGE *    new_data )       /* In: DATAPAGE a ajouter */
  500. {
  501.     DATAPAGE *     pDataPg_Curr = datadir -> data_end;
  502.     DATAPAGE    *    pDataPg_Next = NULL;
  503.     int            n_comp;
  504.  
  505.     while( pDataPg_Curr != NULL )
  506.     {    /*
  507.          * Tant qu'on est pas en 1Šre position:
  508.          */
  509.         n_comp = strcmp( pDataPg_Curr -> nom, new_data -> nom );
  510.     
  511.         if( n_comp == 0 )
  512.         {
  513.             signale( "Nom identiques!");
  514.             break;
  515.         }
  516.         else if( n_comp < 0 )
  517.         {
  518.             break;
  519.         }
  520.  
  521.         /*
  522.          * On se d‚place sur la page pr‚c‚dente:
  523.          */
  524.         pDataPg_Next = pDataPg_Curr;
  525.         pDataPg_Curr = pDataPg_Curr -> prev;
  526.     }    
  527.  
  528.     /*
  529.      * Ceci est la derniŠre page: 
  530.      */
  531.  
  532.     /*
  533.      * On fait pointer la page sur son datadir:
  534.      */
  535.     new_data -> pDataDir = datadir;
  536.             
  537.     /*
  538.      * Liaison bidirectionnelle entre pageq: 
  539.      */
  540.     if( pDataPg_Next == NULL )
  541.     {    /*
  542.          * Si on ajoute … la fin:
  543.          * (cas fr‚quent lors du chargement) 
  544.          */
  545.         if( pDataPg_Curr == NULL ) 
  546.         {
  547.             new_data            -> prev = NULL;
  548.             datadir -> data_start  = new_data;
  549.         }
  550.         else
  551.         {
  552.             new_data         -> prev = pDataPg_Curr;
  553.             pDataPg_Curr    -> next = new_data;
  554.         }
  555.         
  556.         new_data         -> next = NULL;
  557.         datadir -> data_end      = new_data;
  558.     }
  559.     else if( pDataPg_Curr == NULL )
  560.     {    /*
  561.          * Si on ajoute au d‚but du groupe: 
  562.          */
  563.         new_data            -> prev = NULL;
  564.         datadir -> data_start  = new_data;
  565.  
  566.         new_data            -> next = pDataPg_Next;
  567.         pDataPg_Next    -> prev = new_data;
  568.     }
  569.     else
  570.     {    /*
  571.          * Si on ajoute en milieu de groupe:
  572.          */
  573.         new_data -> prev = pDataPg_Curr;
  574.         pDataPg_Curr -> next = new_data;
  575.  
  576.         new_data -> next = pDataPg_Next;
  577.         pDataPg_Next -> prev = new_data;
  578.     }
  579.  
  580.     /*
  581.      * 1 page en PLUS de celles qui existaient d‚j…: 
  582.      */
  583.     (datadir -> nb_elts) ++;    
  584.  
  585. }
  586.  
  587.  
  588.  
  589. /*
  590.  * clearout_datadir(-)
  591.  *
  592.  * Purpose:
  593.  * --------
  594.  * Supprime le contenu d'un DATADIR
  595.  *
  596.  * History:
  597.  * --------
  598.  * 1993: fplanque: Created
  599.  * 15.07.94: ne prend plus de param 'data_type'
  600.  * 26.12.94: update icone
  601.  */
  602. void    clearout_datadir( 
  603.             DATADIR    *    datadir )    /* In: DATADIR … vider */
  604. {            
  605.     int            i                    = 0;
  606.     DATAPAGE        *curr_datapage = datadir -> data_start;    /* Adr 1Šre page en m‚moire */
  607.     DATAPAGE        *next_datapage;
  608.     WIPARAMS        *wi_adr;            /* Fen d'‚dition associ‚ … la page qu'on efface en ce moment */
  609.  
  610.     /*
  611.      * Efface les pages: 
  612.      */
  613.     while ( curr_datapage != NULL )
  614.     {    /*
  615.          * Tant qu'il y a des pages 
  616.          */
  617.         next_datapage = curr_datapage -> next;
  618.         i++;
  619.         
  620.         if( dataPage_IsOpen( curr_datapage ) )
  621.         {    /*
  622.               * S'il y a une fenˆtre d'‚dition ouverte: 
  623.               *
  624.              * Trouve la fenˆtre d'‚dition concern‚e 
  625.              */
  626.             wi_adr = find_datawindow2( (unsigned long) curr_datapage, G_wi_list_adr );
  627.             if ( wi_adr == NULL )
  628.             {
  629.                 ping();                /* ANORMAL! */
  630.             }
  631.             else
  632.             {
  633.                 ferme_fenetre( wi_adr, TRUE_1 );    /* Ferme la fenˆtre */
  634.             }
  635.         }
  636.  
  637.         /*
  638.          * Efface page: 
  639.          */
  640.         efface_page( curr_datapage );
  641.  
  642.         curr_datapage = next_datapage;
  643.     }
  644.  
  645.     /*
  646.      * Plus de page: 
  647.      */
  648.     datadir -> nb_elts        = 0;
  649.     datadir -> data_start    = NULL;
  650.     datadir -> data_end        = NULL;
  651.  
  652.     /*
  653.      * Signale que le datadir est vide:
  654.      */
  655.     dataDir_setSavState( datadir, SSTATE_EMPTY, TRUE_1 );
  656. }
  657.  
  658.  
  659. /*
  660.  * efface_1data(-)
  661.  *
  662.  * Purpose:
  663.  * --------
  664.  * Efface 1 DATAPAGE d'un groupe de donn‚es:
  665.  * maj statut sauvegarde datadirs
  666.  *
  667.  * Notes:
  668.  * ------
  669.  *
  670.  * History:
  671.  * --------
  672.  * 1993: fplanque: Created
  673.  * 09.08.94: fplanque: chang‚ valeur de retour
  674.  * 06.10.94: fplanque: r‚cup le datagrp directement ds le datadir
  675.  */
  676. BOOL    efface_1data(                         /* Out: FALSE0 si pas modifi‚e */ 
  677.             DATADIR     *    datadir,         /* In: DATADIR ds lequel est situé la page */
  678.             DATAPAGE     *    rm_datapage )    /* In: DATAPAGE à effacer */
  679. {
  680.     DATAGROUP *    datagroup = datadir -> pDataGroup;  /* DATAGROUP ds lequel on travaille */
  681.  
  682.     static    char    *conf1 ="[2][|EFFACER la base de|donn‚es: 123456789012|de la m‚moire?][Confirmer|Annuler]";
  683.     static    char    *conf2 ="[3][La base de donn‚es: 123456789012|est en cours d'DITION.|Voulez-vous l'FFACER|quand mˆme?][Confirmer|Voir|Annuler]";
  684.  
  685.     char        *    replace;            /* Remplacement de texte */
  686.     int            pos_nom;                /* Position du nom de la page */
  687.     DATATYPE        type    = datagroup -> DataType;    /* Type de page a effacer */
  688.     int            resultat;            /* Destruction ou pas? */
  689.  
  690.     DATAPAGE    *    prev_datapage = rm_datapage -> prev;    /* Adr page pr‚c‚dente */
  691.     DATAPAGE    *    next_datapage = rm_datapage -> next;    /* Adr page suivante */
  692.     
  693.     /*
  694.      * V‚rifie que la page n'est pas en cours d'‚dition: 
  695.      */
  696.     if ( dataPage_IsOpen( rm_datapage ) )
  697.     {    /* 
  698.           * S'il y a d‚j… une fenˆtre ouverte dessus: 
  699.          * Demande conf:    
  700.          * Fixe type: 
  701.          */
  702.         switch( type )
  703.         {
  704.             case    DTYP_ARBO:
  705.                 replace = "La page arbo:                   ";
  706.                 pos_nom = 18;
  707.                 break;
  708.  
  709.             case    DTYP_PAGES:
  710.                 replace = "La page-‚cran:                  ";
  711.                 pos_nom = 19;
  712.                 break;
  713.  
  714.             case    DTYP_DATAS:
  715.                 replace = "La base de donn‚es:             ";
  716.                 pos_nom = 24;
  717.                 break;
  718.                 
  719.             case    DTYP_TEXTS:
  720.                 replace = "Le texte:                       ";
  721.                 pos_nom = 14;
  722.                 break;
  723.  
  724.             case    DTYP_PICS:
  725.                 replace = "L'image:                        ";
  726.                 pos_nom = 13;
  727.                 break;
  728.  
  729.         }
  730.         memcpy( conf2 + 4, replace , 32);
  731.  
  732.         /*
  733.          * Fixe nom: 
  734.          */
  735.         memcpy( conf2 + pos_nom, rm_datapage -> nom, strlen( rm_datapage -> nom ));    /* Copie nom */
  736.  
  737.         /*
  738.          * Affiche alerte: 
  739.          */
  740.         resultat=form_alert( 2, conf2 );                /* Alerte */
  741.  
  742.         /*
  743.          * Selon le r‚sultat: 
  744.          */
  745.         if( resultat != 3 )        /* Si on a pas annul‚: */
  746.         {    /*
  747.              * Trouve la fenˆtre d'‚dition concern‚e 
  748.              */
  749.             WIPARAMS    * wi_adr = find_datawindow2( (unsigned long) rm_datapage, G_wi_list_adr );
  750.  
  751.             if ( wi_adr == NULL )
  752.                 ping();                /* ANORMAL! */
  753.             else
  754.             {
  755.                 if ( resultat == 1)
  756.                 {    /*
  757.                      * Si on choisi d'effacer le doc: 
  758.                      * On va commencer par fermer la fenˆtre d'‚dition 
  759.                      */
  760.                     ferme_fenetre( wi_adr, TRUE_1 );
  761.                 }
  762.                 else    
  763.                 {    /*
  764.                      * Si on veut voir le doc en question: 
  765.                      * On va le monter au 1er Plan: 
  766.                      */
  767.                     put_wi_on_top( wi_adr );
  768.                 }
  769.             }    
  770.         }
  771.     }
  772.     else        
  773.     {    /*
  774.          * Si l'elt n'est pas en cours d'‚dition 
  775.          * Demande conf:    
  776.          * Fixe type: 
  777.          */
  778.         switch( type )
  779.         {
  780.             case    DTYP_ARBO:
  781.                 replace = "a page   |arbo:                ";
  782.                 pos_nom = 30;
  783.                 break;
  784.  
  785.             case    DTYP_PAGES:
  786.                 replace = "a page   |‚cran:               ";
  787.                 pos_nom = 31;
  788.                 break;
  789.  
  790.             case    DTYP_DATAS:
  791.                 replace = "a base de|donn‚es:             ";
  792.                 pos_nom = 33;
  793.                 break;
  794.                 
  795.             case    DTYP_TEXTS:
  796.                 replace = "e texte: |                     ";
  797.                 pos_nom = 24;
  798.                 break;
  799.  
  800.             case    DTYP_PICS:
  801.                 replace = "'image:  |                     ";
  802.                 pos_nom = 24;
  803.                 break;
  804.  
  805.         }
  806.         memcpy( conf1 + 14, replace , 31);
  807.  
  808.         /*
  809.          * Fixe nom: 
  810.          */
  811.         memcpy( conf1 + pos_nom, rm_datapage -> nom, strlen( rm_datapage -> nom ));    /* Copie nom */
  812.  
  813.         /*
  814.          * Affiche alerte: 
  815.          */
  816.         resultat=form_alert( 2, conf1 );                /* Alerte */
  817.     }
  818.  
  819.     if ( resultat != 1 )        
  820.     {    /*
  821.          * Si on a annul‚ l'effacement 
  822.          */
  823.         return    FALSE0;                /* Pas de modif (pas d'effacement) */    
  824.     }
  825.     
  826.     
  827.     /* TRACE2( "Gonna erase DataPage: %lu %s", rm_datapage, rm_datapage-> nom ); */
  828.     
  829.     /*
  830.      * Efface page: 
  831.      */
  832.     efface_page( rm_datapage );
  833.  
  834.     /*
  835.      * Une page de moins: 
  836.      */
  837.     (datadir -> nb_elts)--;
  838.  
  839.     /*
  840.      * Liens: 
  841.      */
  842.     /* Pr‚c -> Suiv: */
  843.     if ( prev_datapage != NULL )    /* Si on a pas ‚ffac‚ la premiŠre page */
  844.     {
  845.         prev_datapage -> next = next_datapage;
  846.     }
  847.     else    /* Si on a effac‚ la 1Šre page: */
  848.     {
  849.         datadir -> data_start = next_datapage;
  850.     }
  851.  
  852.     /* Pr‚c <- Suiv: */
  853.     if ( next_datapage != NULL )    /* Si on a pas ‚ffac‚ la derniŠre page */
  854.     {
  855.         next_datapage -> prev = prev_datapage;
  856.     }
  857.     else    /* Si on a effac‚ la derniŠre page: */
  858.     {
  859.         datadir -> data_end = prev_datapage;
  860.     }
  861.  
  862.     /*
  863.      * Mise … jour des fenˆtres: 
  864.      */
  865.     if ( type != DTYP_ARBO )
  866.     { /*
  867.          * Si on est pas sur une page arbo: 
  868.         * On va metre … jour la fenˆtre: 
  869.         * On considŠre qu'il y a au moins 1 fenˆtre ouverte, 
  870.         * Sinon on aurait pas pu effacer...
  871.         */
  872.         remplace_dir( datadir );
  873.     }
  874.  
  875.     /*
  876.      * Status mise … jour: 
  877.      */
  878.     dataDir_setSavState( datadir, SSTATE_MODIFIED, TRUE_1 );
  879.                 
  880.     return    TRUE_1;            /* Modif effectu‚e */
  881.  
  882. }
  883.  
  884.  
  885.  
  886.  
  887.  
  888.  
  889. /*
  890.  * close_datawindows(-)
  891.  *
  892.  * Purpose:
  893.  * --------
  894.  * Ferme toutes les fenˆtres d'un DATADIR
  895.  *
  896.  * Algorythm:
  897.  * ----------  
  898.  * Parcourt la liste des fenetres a la recherche de celles qui
  899.  * affiche le DATAGROUP en question.
  900.  *
  901.  * History:
  902.  * --------
  903.  * 1993: fplanque: Created
  904.  */
  905. void    close_datawindows( 
  906.             DATADIR *datadir )    /* In: DATADIR dont on veut fermer les fenêtres */
  907. {
  908.     /* PremiŠre fen concern‚e: */
  909.     WIPARAMS    *curr_wi_adr;
  910.  
  911.     /* printf("Datadir:%lu nb_dirs=%d \n", datadir, datadir -> nb_dirs ); */
  912.  
  913.     /* Fermeture: */
  914.     while
  915.         (    /* Cherche 1Šre fen concern‚e dans la liste: */
  916.         /* (On cherche toujous la 1ERE car dŠs qu'on en ferme une, elle d‚gage de la liste, la suivante devient alors PREMIERE!) */
  917.         curr_wi_adr = find_datawindow2( (unsigned long) datadir, G_wi_list_adr ),
  918.         curr_wi_adr != NULL
  919.     )
  920.     {    /* Tant qu'on a trouv‚ une fenˆtre … fermer: */
  921.         /*    printf("Adr Fen concern‚e: %lX\n",curr_wi_adr); */
  922.  
  923.         /* Ferme la fenˆtre: */
  924.         ferme_fenetre( curr_wi_adr, TRUE_1 );
  925.  
  926.     }
  927. }
  928.  
  929.  
  930.  
  931.  
  932.  
  933. /*
  934.  * page_adr_byicno(-)
  935.  *
  936.  * Purpose:
  937.  * --------
  938.  * Trouve l'adresse d'une page en fonction de son no
  939.  *
  940.  * History:
  941.  * --------
  942.  * 1993: fplanque: Created
  943.  * 21.09.94: tests d'erreur
  944.  */
  945. DATAPAGE    * page_adr_byicno(         /* Out: Ptr sur la page trouvée */
  946.                 DATADIR* datadir,     /* In: DATADIR ds lequel se trouve la page */
  947.                 int page_no )            /* In: No d'ordre de la page ds le groupe */
  948. {
  949.     DATAPAGE    *page_ptr = datadir -> data_start;    /* Adr 1Šre page */
  950.     int        i;                        /* Compteur */
  951.     
  952.     if( page_no < 1 )
  953.     {
  954.         return    NULL;
  955.     }
  956.  
  957.     for
  958.     (
  959.         i = 1;                                        /* D‚but en 1 */
  960.         i < page_no;                                /* Tant que pas au bon no */
  961.         i++, page_ptr = page_ptr -> next        /* -> Passe … page suivante */
  962.     )
  963.     {
  964.         if( page_ptr == NULL )
  965.         {
  966.             return    NULL;
  967.         }    
  968.     }
  969.     return    page_ptr;
  970.  
  971. }
  972.  
  973.  
  974.  
  975. /*
  976.  * count_pages(-)
  977.  *
  978.  * Purpose:
  979.  * --------
  980.  * Compte le nombre de pages d'un DATADIR
  981.  *
  982.  * History:
  983.  * --------
  984.  * fplanque: Created
  985.  */
  986. int count_pages( 
  987.         DATADIR *datadir )    /* In: DATADIR dont on veut compter les pages */
  988. {
  989.     DATAPAGE    *page_ptr = datadir -> data_start;    /* Adr 1Šre page */
  990.     int        nb_pages  = 0;            /* Compteur */
  991.     
  992.     while ( page_ptr != NULL )
  993.     {
  994.         nb_pages ++;                        /* 1 page de plus */
  995.         page_ptr = page_ptr -> next;    /* Passe sur la page suivante */
  996.     };
  997.  
  998.     return    nb_pages;
  999.  
  1000. }
  1001.  
  1002.  
  1003.  
  1004. /*
  1005.  * page_adr_byname(-)
  1006.  *
  1007.  * Purpose:
  1008.  * --------
  1009.  * Trouve l'adresse d'une page d'aprŠs son nom
  1010.  *
  1011.  * Algorythm:
  1012.  * ----------  
  1013.  * Cette routine compare juste les pointeurs! 
  1014.  * (utilis‚e dans l'‚dition arbo) 
  1015.  *
  1016.  * Notes:
  1017.  * ------
  1018.  * Ceci est rapide mais dangereux! On peut mal utiliser cette fonction.
  1019.  * Une autre ci-dessous, fait une comparaison r‚elle
  1020.  *
  1021.  * History:
  1022.  * --------
  1023.  * 1993: fplanque: Created
  1024.  */
  1025. DATAPAGE    * page_adr_byname( 
  1026.                 DATADIR *datadir, 
  1027.                 char *name )
  1028. {
  1029.     DATAPAGE    *page_ptr = datadir -> data_start;    /* Adr 1Šre page */
  1030.  
  1031.     /* TRACE2( "Datadir=%lu Page=%s", datadir, name); */
  1032.  
  1033.     while ( page_ptr != NULL )
  1034.     {
  1035.         /* TRACE1( "Found=%s", page_ptr -> nom ); */
  1036.  
  1037.           if( page_ptr -> nom == name )
  1038.           {
  1039.               break;
  1040.           }
  1041.  
  1042.         page_ptr = page_ptr -> next;
  1043.     }
  1044.  
  1045.     /* TRACE0( "End search" ); */
  1046.     if( page_ptr == NULL )
  1047.     {
  1048.         ping();
  1049.         TRACE1( "Page %s non trouv‚e", name );
  1050.     }
  1051.  
  1052.     return    page_ptr;
  1053. }
  1054.  
  1055.  
  1056.  
  1057. /*
  1058.  * page_adr_bynamecmp(-)
  1059.  *
  1060.  * Purpose:
  1061.  * --------
  1062.  * Cette routine, plus lente, 
  1063.  * trouvera la page mˆme si on lui fourni
  1064.  * une copie du nom, (adr m‚moire diff‚rente)
  1065.  *
  1066.  * Algorythm:
  1067.  * ----------  
  1068.  * Cette routine compare donc r‚ellement les 2 chaines nom
  1069.  *
  1070.  * Notes:
  1071.  * ------
  1072.  * Voir aussi la fonction qui compare les pointeurs
  1073.  *
  1074.  * History:
  1075.  * --------
  1076.  * 1993: fplanque: Created
  1077.  */
  1078. DATAPAGE    * page_adr_bynamecmp(         /* Out: Ptr sur DATAPAGE, NULL si pas trouv‚ */
  1079.                     DATADIR        *    datadir, /* In:  DATADIR ds lequel on doit chercher la page */
  1080.                     const char    *    name )    /* In:  Nom de la page qu'on recherche */
  1081. {
  1082.     DATAPAGE    *page_ptr = datadir -> data_start;    /* Adr 1Šre page */
  1083.  
  1084.     while ( page_ptr != NULL  && strcmp( (page_ptr -> nom), name ) != 0 )
  1085.     {
  1086.         page_ptr = page_ptr -> next;
  1087.     }
  1088.  
  1089.     return    page_ptr;
  1090. }
  1091.  
  1092.  
  1093. /*
  1094.  * page_fullpath(-)
  1095.  *
  1096.  * Purpose:
  1097.  * --------
  1098.  * Cr‚e le chemin d'accŠs complet … une page
  1099.  *
  1100.  * Algorythm:
  1101.  * ----------  
  1102.  * Operations sur chaines de caractŠres:
  1103.  *
  1104.  * Notes:
  1105.  * ------
  1106.  *    Cette fonction suppose que la page est dans le root
  1107.  *
  1108.  * History:
  1109.  * --------
  1110.  * 1994: fplanque: Created
  1111.  * 14.12.94: prend DATADIR en param
  1112.  */
  1113. char    *    page_fullpath( 
  1114.         DATADIR    *    pDataDir,    /* In: DATADIR ds lequel doit se trouver la page */
  1115.         char         *    name )        /* In: Nom de la page */
  1116. {
  1117.     DATAGROUP    *    pDataGrp = pDataDir -> pDataGroup;
  1118.     size_t    length = strlen( pDataGrp -> data_device ) +1 /* le '\' */ 
  1119.                             + strlen( name ) + 1; /* Longueur */
  1120.     char        *fullpath = (char *) MALLOC( length );
  1121.  
  1122.     /* 
  1123.      * Cr‚ation path: 
  1124.      */
  1125.     strcpy( fullpath, pDataGrp -> data_device );    /* Copie ROOT */
  1126.     strcat( fullpath, "\\" );                            /* Ajoute backslash */
  1127.     strcat( fullpath, name );                            /* Ajoute NOM */
  1128.  
  1129.     return    fullpath;
  1130. }
  1131.  
  1132. char    *    page_fullpath_old( 
  1133.         DATAGROUP    *    pDataGrp,    /* In: DATAGROUP ds lequel doit se trouver la page */
  1134.         char         *    name )        /* In: Nom de la page */
  1135. {
  1136.     size_t    length = strlen( pDataGrp -> data_device ) +1 /* le '\' */ 
  1137.                             + strlen( name ) + 1; /* Longueur */
  1138.     char        *fullpath = (char *) MALLOC( length );
  1139.  
  1140.     /* 
  1141.      * Cr‚ation path: 
  1142.      */
  1143.     strcpy( fullpath, pDataGrp -> data_device );    /* Copie ROOT */
  1144.     strcat( fullpath, "\\" );                            /* Ajoute backslash */
  1145.     strcat( fullpath, name );                            /* Ajoute NOM */
  1146.  
  1147.     return    fullpath;
  1148. }
  1149.  
  1150.